Contemporary computer networks consist of a number of computer systems, called nodes, communicating with other computer systems via communication links. Typically, some of the nodes are client nodes and other nodes are server nodes. A client node formulates and delivers queries to a server node. A user of the client node enters the queries through a user-interface operating on the client node. The server node evaluates the queries and delivers responses to the client node for display on the client user-interface.
Usually, the server nodes host a variety of application programs or processes that can be accessed and executed by client nodes. When a client node launches an application program, the execution of that application program can occur at either the client node or the server node, depending upon the computing model followed by the computer network.
In a client-based computing model, the application program is packaged and sent down to, or pre-installed on, the client node, allowing the client node to run the application using the resources of the client node. This approach has several drawbacks. First, the client node must have sufficient memory, disk space, and processing power to effectively execute the application. A related problem that occurs using this model is that the number of applications a given client is able to execute is limited due to client resource constraints. Further, applications built this way are complex to develop and maintain and typically require modification or “porting” for all supported client computer system types. Moreover, this technique exacerbates the administration burden on a network administrator.
In a server-based computing model, the server node executes the application program, and only the control information for the client user-interface is transmitted across the computer network to the client node for display. Using this approach, user-interface events must be sent between the client and the server in order for the server application to process the events. This may result in perceived delays of user-interface response. Further, the application program must be specifically written, or changed, to support the user-interface on the client node. This increases the complexity of the application and prevents this technique from being useful with off-the-shelf applications.
A refinement of the server-based model is to supplant the device driver to which the application communicates in order to send screen and device updates back and forth between the client and the server. This approach avoids requiring applications to be rewritten. However, this approach requires device information to be sent between the client and the server in order to maintain the client display, again introducing perceived latency into the interface. Further, server-side processing requirements are increased in order to satisfy resulting device information required for communication with each connected client.
A recent, further refinement of the server-based model is to deploy the user-interface portion of the application as a mark-up language document such as Hyper Text Markup Language (HTML) document. However in using this approach, information sent from the server application to the client begins to “age” immediately. In other words the information may change on the server but the client would not automatically be notified and updated. Further, with this approach, interactivity requires context switching between pages even to perform simple tasks.
Standard and emerging approaches to application development for Web application delivery rely on one of two approaches. The first approach is adapting ‘page based’ application delivery code (e.g., servlets) to more dynamic use (e.g., sequence of servlets). The second approach is wiring user-interface components to server components. The first approach has the advantage of remaining Web-centric and within the skill set of Web developers, but is limited by its page-based roots. Generating applications with a user-interface using several pages (or dialogues) typically requires coordinating the server-side components to generate each page on an individual basis. This coordination becomes very difficult as the number of pages or the number of clients increases. The second approach, wiring, still requires the application developer to deal with the dynamic aspects of the application, as a developer must wire to existing object instances that the wiring tool knows about. This is typically objects that exist at application start up, or at other well defined times. The second approach typically requires customized tools to perform all aspects of UI design, including layout and formatting.